// 
//  Copyright 2011  reda
// 
//    Licensed under the Apache License, Version 2.0 (the "License");
//    you may not use this file except in compliance with the License.
//    You may obtain a copy of the License at
// 
//        http://www.apache.org/licenses/LICENSE-2.0
// 
//    Unless required by applicable law or agreed to in writing, software
//    distributed under the License is distributed on an "AS IS" BASIS,
//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//    See the License for the specific language governing permissions and
//    limitations under the License.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using ManiacMusicManager.Data.Core;
using ManiacMusicManager.Data.DAO.Ifaces;
using ManiacMusicManager.Data.Utils;
namespace ManiacMusicManager.Data.DAO
{
	public abstract partial class AbstractDAO<T> : IDAO<T>
		where T : Entity
	{
		/// <summary>
		/// Retourne une requête qui filtre les objets selon un texte
		/// </summary>
		/// <param name="strGet">
		/// Expression qui d'un objet retourne la valeur sur laquelle s'appliquera le filtre
		/// </param>
		/// <param name="value">
		/// Valeur critere du filtre
		/// </param>
		/// <param name="options">
		/// Options de recherche
		/// </param>
		/// <returns>
		/// Requête d'objets réutilisable
		/// </returns>
		public IQueryable<T> FilterOnText(Expression<Func<T, string>> strGet, string value, StringSearchOptions options) {
			//FIXME StartsWith, EndsWith et Contains ne prennent pas en compte la casse sous Linq to NHibernate
			Expression valExpr = (options.IsIgnoreCase())?Expression.Constant(value.ToLower()):Expression.Constant(value);
			
			var param = Expression.Parameter(typeof(T), "x");
			Expression query = Expression.Invoke(strGet, param);
			
			if(options.IsIgnoreCase())
				query = Expression.Call(query, toLowerInfo, new Expression[] {});
			
			if(options.IsContains())
				query = Expression.Call(query, containsInfo, valExpr);
			else if(options.IsStartsWith())
				query = Expression.Call(query, startsWithInfo, valExpr);
			else if(options.IsEndsWith())
				query = Expression.Call(query, endsWithInfo, valExpr);
			else
				query = Expression.Equal(query, valExpr);
			
			var lambda = Expression.Lambda<Func<T, bool>>(query, param);
			
			return this.Linq().Where(lambda);
		}
		
		/// <summary>
		/// Retourne une requête qui filte les objets selon un texte dans une liste
		/// </summary>
		/// <param name="lstGet">
		/// Expression qui d'un objet retourne la valeur sur laquelle s'appliquera le filtre
		/// </param>
		/// <param name="value">
		/// Valeur critere du filtre
		/// </param>
		/// <param name="options">
		/// Options de recherche
		/// </param>
		/// <returns>
		/// Requête d'objets réutilisable
		/// </returns>
		public IQueryable<T> FilterOnStringList (Expression<Func<T, IEnumerable<string>>> lstGet, string value, StringSearchOptions options)
		{
			Expression valExpr = (options.IsIgnoreCase())?Expression.Constant(value.ToLower()):Expression.Constant(value);
			var bigparam = Expression.Parameter(typeof(T), "x");
			Expression bigquery = Expression.Invoke(lstGet, bigparam);
			
			var param = Expression.Parameter(typeof(string), "y");
			Expression query = param;
			
			if(options.IsIgnoreCase())
				query = Expression.Call(query, toLowerInfo, new Expression[] {});
			
			if(options.IsContains())
				query = Expression.Call(query, containsInfo, valExpr);
			else if(options.IsStartsWith())
				query = Expression.Call(query, startsWithInfo, valExpr);
			else if(options.IsEndsWith())
				query = Expression.Call(query, endsWithInfo, valExpr);
			else
				query = Expression.Equal(query, valExpr);

			bigquery = Expression.Call(bigquery,anyInfo, query);
			
			var biglambda = Expression.Lambda<Func<T, bool>>(bigquery, bigparam);
			return this.Linq().Where(biglambda);
		}
		
		/// <summary>
		/// Retourne une requête qui filte les objets selon une valeur entiere comprise entre <paramref name="minValue"/> et <paramref name="maxValue"/>
		/// </summary>
		/// <param name="intGet">
		/// Expression qui d'un objet retourne la valeur sur laquelle s'appliquera le filtre
		/// </param>
		/// <param name="minValue">
		/// Valeur minimale (inclue)
		/// </param>
		/// <param name="minValue">
		/// Valeur maximale (inclue)
		/// </param>
		/// <returns>
		/// Requête d'objets réutilisable
		/// </returns>
		public IQueryable<T> FilterOnInteger(Expression<Func<T, int>> intGet, int minValue, int maxValue) {
			Expression minExpr = Expression.Constant(minValue);
			Expression maxExpr = Expression.Constant(maxValue);
			
			var param = Expression.Parameter(typeof(T), "x");
			Expression query = Expression.Invoke(intGet, param);
			
			var minimumTest = Expression.GreaterThanOrEqual(query, minExpr);
			var maximumTest = Expression.LessThanOrEqual(query, maxExpr);
			query = Expression.And(minimumTest, maximumTest);
			
			var lambda = Expression.Lambda<Func<T, bool>>(query, param);
			
			return this.Linq().Where(lambda);
		}
		
		/// <summary>
		/// Retourne une requête qui filte les objets selon une valeur entiere égale à  <paramref name="value"/>
		/// </summary>
		/// <param name="intGet">
		/// Expression qui d'un objet retourne la valeur sur laquelle s'appliquera le filtre
		/// </param>
		/// <param name="value">
		/// Valeur critere exacte
		/// </param>
		/// <returns>
		/// Requête d'objets réutilisable
		/// </returns>
		public IQueryable<T> FilterOnInteger(Expression<Func<T, int>> intGet, int value) {
			Expression valExpr = Expression.Constant(value);
			
			var param = Expression.Parameter(typeof(T), "x");
			Expression query = Expression.Invoke(intGet, param);
			query = Expression.Equal(query, valExpr);
			
			var lambda = Expression.Lambda<Func<T, bool>>(query, param);
			
			return this.Linq().Where(lambda);
		}
	}
}

